home *** CD-ROM | disk | FTP | other *** search
/ Java 1996 August / Java - Summer 1996.iso / sundist / java / cmcmanis / MessageDigest.java < prev    next >
Encoding:
Java Source  |  1995-09-10  |  5.7 KB  |  237 lines
  1. /*
  2.  * @(#)MessageDigest.java    1.1 95/04/02  
  3.  *
  4.  * Copyright (c) 1994 Sun Microsystems, Inc. All Rights Reserved.
  5.  *
  6.  * Permission to use, copy, modify, and distribute this software
  7.  * and its documentation for NON-COMMERCIAL purposes and without
  8.  * fee is hereby granted provided that this copyright notice
  9.  * appears in all copies. Please refer to the file "copyright.html"
  10.  * for further important copyright and licensing information.
  11.  *
  12.  * SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF
  13.  * THE SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
  14.  * TO THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
  15.  * PARTICULAR PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR
  16.  * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
  17.  * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES.
  18.  */
  19.  
  20. package java.crypt;
  21.  
  22. import java.util.*;
  23. import java.lang.*;
  24. import java.io.OutputStreamBuffer;
  25. import java.io.PrintStream;
  26.  
  27.  
  28. /**
  29.  * The MessageDigest class defines a general class for computing digest
  30.  * functions. It is defined as an abstract class that is subclassed by
  31.  * message digest algorithms. In this way the PKCS classes can be built
  32.  * to take a MessageDigest object without needing to know what 'kind'
  33.  * of message digest they are computing.
  34.  *
  35.  * This class defines the standard functions that all message digest
  36.  * algorithms share, and ways to put all Java fundamental types into
  37.  * the digest. It does not define methods for digestifying either
  38.  * arbitrary objects or arrays of objects however.
  39.  *
  40.  * @version     02 Apr 1995, 1.1
  41.  * @author     Chuck McManis
  42.  */
  43. public class MessageDigest {
  44.  
  45.     /** the actual digest bits. */
  46.     public byte digestBits[];
  47.  
  48.     /** status of the digest */
  49.     public boolean digestValid;
  50.  
  51.     /**
  52.      * This function is used to initialize any internal digest
  53.      * variables or parameters.
  54.      */
  55.     public abstract void init();
  56.  
  57.     /**
  58.      * The basic unit of digestifying is the byte. This method is
  59.      * defined by the particular algorithim's subclass for that
  60.      * algorithim. Subsequent versions of this method defined here
  61.      * decompose the basic type into bytes and call this function.
  62.      * If special processing is needed for a particular type your
  63.      * subclass should override the method for that type. 
  64.      */
  65.     public abstract void update(byte aValue);
  66.  
  67.     public synchronized void update(boolean aValue) {
  68.     byte    b;
  69.  
  70.     if (aValue)
  71.         b = 1;
  72.     else
  73.         b = 0;
  74.     update(b);
  75.     }
  76.  
  77.     public synchronized void update(short aValue) {
  78.     byte    b1, b2;
  79.     
  80.     b1 = (byte)((aValue >>> 8) & 0xff);
  81.     b2 = (byte)(aValue & 0xff);
  82.     update(b1);
  83.     update(b2);
  84.     }
  85.  
  86.     public synchronized void update(int aValue) {
  87.     byte    b;
  88.     
  89.     for (int i = 3; i >= 0; i--) {
  90.         b = (byte)((aValue >>> (i * 8)) & 0xff);
  91.         update(b);
  92.     }
  93.     }
  94.  
  95.     public synchronized void update(long aValue) {
  96.     byte    b;
  97.     
  98.     for (int i = 7; i >= 0; i--) {
  99.         b = (byte)((aValue >>> (i * 8)) & 0xff);
  100.         update(b);
  101.     }
  102.     }
  103.  
  104.     public synchronized void update(byte input[]) {
  105.     for (int i = 0; i < input.length; i++) {
  106.         update(input[i]);
  107.     }
  108.     }
  109.  
  110.     public synchronized void update(short input[]) {
  111.     for (int i = 0; i < input.length; i++) {
  112.         update(input[i]);
  113.     }
  114.     }
  115.  
  116.     public synchronized void update(int input[]) {
  117.     for (int i = 0; i < input.length; i++) {
  118.         update(input[i]);
  119.     }
  120.     }
  121.  
  122.     public synchronized void update(long input[]) {
  123.     for (int i = 0; i < input.length; i++) {
  124.         update(input[i]);
  125.     }
  126.     }
  127.  
  128.     /**
  129.      * Add the bytes in the String 'input' to the current digest.
  130.      * Note that the string characters are treated as unicode chars
  131.      * of 16 bits each. To digestify ISO-Latin1 strings (ASCII) use
  132.      * the updateASCII() method.
  133.      */
  134.     public void update(String input) {
  135.     int    i, len;
  136.     short    x;
  137.  
  138.     len = input.length();
  139.     for (i = 0; i < len; i++) {
  140.         x = (short) input.charAt(i);
  141.         update(x);
  142.     }
  143.     }
  144.  
  145.     /**
  146.      * Treat the string as a sequence of ISO-Latin1 (8 bit) characters.
  147.      */
  148.     public void updateASCII(String input) {
  149.     int    i, len;
  150.     byte    x;
  151.  
  152.     len = input.length();
  153.     for (i = 0; i < len; i++) {
  154.         x = (byte) (input.charAt(i) & 0xff);
  155.         update(x);
  156.     }
  157.     }
  158.  
  159.     /**
  160.      * Perform the final computations and cleanup.
  161.      */
  162.     public abstract void finish();
  163.  
  164.     /**
  165.      * Complete digest computation on an array of bytes.
  166.      */
  167.     public void computeDigest(byte source[]) {
  168.     init();
  169.     update(source);
  170.     finish();
  171.     }
  172.  
  173.     /**
  174.      * helper function that prints unsigned two character hex digits.
  175.      */
  176.     private void hexDigit(PrintStream p, byte x) {
  177.     char c;
  178.     
  179.     c = (char) ((x >> 4) & 0xf);
  180.     if (c > 9)
  181.         c = (char) ((c - 10) + 'A');
  182.     else
  183.         c = (char) (c + '0');
  184.     p.write(c);
  185.     c = (char) (x & 0xf);
  186.     if (c > 9)
  187.         c = (char)((c-10) + 'A');
  188.     else
  189.         c = (char)(c + '0');
  190.     p.write(c);
  191.     }
  192.  
  193.     /**
  194. `    * Return a string representation of this object.
  195.      */
  196.     public String toString() {
  197.     OutputStreamBuffer ou = new OutputStreamBuffer();
  198.     PrintStream p = new PrintStream(ou);
  199.         
  200.     p.print(this.getClass().getName()+" Message Digest ");
  201.     if (digestValid) {
  202.         p.print("<");
  203.         for(int i = 0; i < digestBits.length; i++)
  204.              hexDigit(p, digestBits[i]);
  205.         p.print(">");
  206.     } else {
  207.         p.print("<incomplete>");
  208.     }
  209.     p.println();
  210.     return (ou.toString());
  211.     }
  212.  
  213.     /**
  214.      * Compare two digests for equality. Simple byte compare.
  215.      */
  216.     public static boolean isEqual(byte digesta[], byte digestb[]) {
  217.     int    i;
  218.         
  219.     if (digesta.length != digestb.length)
  220.         return (false);
  221.  
  222.     for (i = 0; i < digesta.length; i++) {
  223.         if (digesta[i] != digestb[i]) {
  224.         return (false);
  225.         }
  226.     }
  227.     return (true);
  228.     }
  229.  
  230.     /**
  231.      * Non static version that compares this digest to one passed.
  232.      */
  233.     public boolean isEqual(byte otherDigest[]) {
  234.     return (MessageDigest.isEqual(digestBits, otherDigest));
  235.     }
  236. }
  237.